package router

import (
	"odm/com"
	"odm/logger"
	"odm/model"

	"github.com/kataras/iris/v12"
)

func login(ctx iris.Context) {
	// 登录用户数据结构
	type User struct {
		Uid      string `json:"uid"`
		Password string `json:"password"`
	}

	user := new(User)
	if err := ctx.ReadJSON(user); err != nil {
		logger.Errorf("数据绑定异常:%s", err)
		ctx.StopWithJSON(iris.StatusBadRequest, iris.Map{"status": false, "message": "数据绑定异常"})
		return
	}

	// 查询数据库
	userDb, err := model.GetUser(user.Uid)
	if err != nil {
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}
	// 检验密码
	if err := com.VerifyPassword(userDb.Password, userDb.Salt+user.Password); err != nil {
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}
	// 生成令牌
	token, err := com.GenToken(user.Uid, userDb.Role)
	if err != nil {
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}
	// 登录成功
	ctx.JSON(iris.Map{"status": true, "message": "登录成功", "name": userDb.Name, "token": token, "role": userDb.Role})
}

func getUserList(ctx iris.Context) {
	ctx.JSON(model.GetUsers())
}

func changePassword(ctx iris.Context) {
	type User struct {
		Uid     string `json:"uid"`
		OldPass string `json:"old_pass"`
		NewPass string `json:"new_pass"`
	}
	user := new(User)
	if err := ctx.ReadJSON(user); err != nil {
		logger.Errorf("数据绑定异常:%s", err)
		ctx.StopWithJSON(iris.StatusBadRequest, iris.Map{"status": false, "message": "数据绑定异常"})
		return
	}
	// 查询数据库
	userDb, err := model.GetUser(user.Uid)
	if err != nil {
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}
	// 检验密码
	if err := com.VerifyPassword(userDb.Password, userDb.Salt+user.OldPass); err != nil {
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}
	// 获取新密码
	password, salt, err := com.GetPassword(user.NewPass, true)
	if err != nil {
		logger.Errorf("密码获取失败:%s", err)
		ctx.JSON(iris.Map{"status": false, "message": "密码获取失败"})
		return
	}
	// 密码修改
	if err := model.Reset(user.Uid, password, salt); err != nil {
		logger.Error(err.Error())
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}
	ctx.JSON(iris.Map{"status": true, "message": "密码修改成功"})
}

// register user
func register(ctx iris.Context) {
	type User struct {
		Uid      string `json:"uid"`
		Name     string `json:"name"`
		Role     string `json:"role"`
		Password string `json:"password"`
	}
	user := new(User)
	err := ctx.ReadJSON(user)
	if err != nil {
		logger.Errorf("数据绑定异常:%s", err)
		ctx.JSON(iris.Map{"status": false, "message": "数据绑定异常"})
		return
	}
	// 检查用户用户是否存在
	if model.IsUserExists(user.Uid) {
		ctx.JSON(iris.Map{"status": false, "message": "用户已存在"})
		return
	}
	// 获取新密码
	password, salt, err := com.GetPassword(user.Password, true)
	if err != nil {
		logger.Errorf("密码获取失败:%s", err)
		ctx.JSON(iris.Map{"status": false, "message": "密码获取失败"})
		return
	}
	// 增加新用户
	newUser := &model.User{
		Uid:      user.Uid,
		Salt:     salt,
		Password: password,
		Name:     user.Name,
		Role:     user.Role,
		Status:   true,
	}
	if err := model.CreateUser(newUser); err != nil {
		logger.Error(err.Error())
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}
	ctx.JSON(iris.Map{"status": true, "message": "用户注册成功"})
}

// // reset reset user password
// func reset(ctx iris.Context) {
// 	username := ctx.Params().Get("username")
// 	// 获取新密码
// 	password, salt, err := api.GetPassword(username+"-a1s2d3", false)
// 	if err != nil {
// 		logger.Errorf("密码获取失败 [%s]", err)
// 		ctx.JSON(iris.Map{"status": false, "message": "密码获取失败"})
// 		return
// 	}
// 	// 密码修改
// 	user := &model.UserReset{Username: username, Password: password, Salt: salt}
// 	if _, err := model.Reset(user); err != nil {
// 		logger.Error(err)
// 		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
// 		return
// 	}
// 	// 密码重置成功
// 	ctx.JSON(iris.Map{"status": true, "message": "用户密码初始化成功"})
// }

// 设置用户状态
func setUserStatus(ctx iris.Context) {
	type User struct {
		Uid    string `json:"uid"`
		Status bool   `json:"status"`
	}
	user := new(User)
	if err := ctx.ReadJSON(user); err != nil {
		logger.Errorf("数据绑定异常:%s", err)
		ctx.JSON(iris.Map{"status": false, "message": "数据绑定异常"})
		return
	}
	// 检查删除的用户是否存在
	userDb, err := model.GetUser(user.Uid)
	if err != nil {
		logger.Error(err.Error())
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}

	// 检查是否可以设置用户状态
	if userDb.Role == "admin" && model.IsOnlyAdminkUser() && !user.Status {
		logger.Error("禁止设置唯一的管理员用户为无效")
		ctx.JSON(iris.Map{"status": false, "message": "禁止设置唯一的管理员用户为无效"})
		return
	}

	// 用户状态修改
	if err := model.SetUserStatus(user.Uid, user.Status); err != nil {
		logger.Error(err.Error())
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}
	// 用户状态修改成功
	ctx.JSON(iris.Map{"status": true, "message": "用户状态修改成功"})
}

// 删除用户
func removeUser(ctx iris.Context) {
	uid := ctx.Params().Get("uid")

	// 检查删除的用户是否存在
	user, err := model.GetUser(uid)
	if err != nil {
		logger.Error(err.Error())
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}

	// 检查是否可以删除用户
	if user.Role == "admin" && model.IsOnlyAdminkUser() {
		logger.Error("禁止删除唯一的管理员用户")
		ctx.JSON(iris.Map{"status": false, "message": "禁止删除唯一的管理员用户"})
		return
	}

	// 删除用户
	if err := model.RemoveUser(uid); err != nil {
		logger.Error(err.Error())
		ctx.JSON(iris.Map{"status": false, "message": err.Error()})
		return
	}

	// 删除用户成功
	ctx.JSON(iris.Map{"status": true, "message": "删除用户成功"})
}
